package chain

import (
	"fmt"
	"math/rand"
	"time"
)

// 实际业务场景：电商订单处理系统

// 假设我们有一个电商订单处理系统，需要多个步骤处理订单：
// 库存验证
// 欺诈检测
// 支付处理
// 物流安排
// 通知发送

// 每个步骤都可能拒绝订单或将其传递给下一个处理步骤。

// ========= 订单对象 =========
type Order struct {
	ID         string
	Items      []string
	TotalPrice float64
	CustomerID string
	Address    string
	Email      string
	Phone      string
	Status     string
}

func NewOrder(items []string, price float64, customerID, address, email, phone string) *Order {
	return &Order{
		ID:         generateOrderID(),
		Items:      items,
		TotalPrice: price,
		CustomerID: customerID,
		Address:    address,
		Email:      email,
		Phone:      phone,
		Status:     "Created",
	}
}

func generateOrderID() string {
	rand.Seed(time.Now().UnixNano())
	return fmt.Sprintf("ORD-%d-%d", time.Now().Unix(), rand.Intn(1000))
}

// OrderHandler 订单处理器
type OrderHandler interface {
	Handle(order *Order) bool
	SetNext(OrderHandler)
}

// BaseHandler 基础订单处理器
type BaseHandler struct {
	next OrderHandler
}

func (h *BaseHandler) SetNext(next OrderHandler) {
	h.next = next
}

func (h *BaseHandler) HandleNext(order *Order) bool {
	if h.next != nil {
		return h.next.Handle(order)
	}
	return true // 链结束，处理成功
}

// ========= 具体订单处理器 =========
// 库存验证处理器
type InventoryHandler struct {
	BaseHandler
}

func (h *InventoryHandler) Handle(order *Order) bool {
	fmt.Printf("[库存验证] 验证订单 %s 的库存...\n", order.ID)
	
	// 模拟库存检查 - 10%概率库存不足
	if rand.Intn(10) == 0 {
		fmt.Printf("❌ 库存不足，订单 %s 被拒绝\n", order.ID)
		order.Status = "Rejected: Inventory Insufficient"
		return false
	}
	
	fmt.Printf("✅ 库存验证通过\n")
	return h.HandleNext(order)
}

// 2. 欺诈检测处理器
type FraudDetectionHandler struct {
	BaseHandler
}

func (h *FraudDetectionHandler) Handle(order *Order) bool {
	fmt.Printf("[欺诈检测] 分析订单 %s 的风险...\n", order.ID)
	
	// 模拟欺诈检测 - 高风险订单
	if order.TotalPrice > 10000 || len(order.Items) > 10 {
		fmt.Printf("⚠️ 高风险订单 %s，进行额外验证...\n", order.ID)
		
		// 5%概率检测为欺诈
		if rand.Intn(20) == 0 {
			fmt.Printf("❌ 欺诈检测失败，订单 %s 被拒绝\n", order.ID)
			order.Status = "Rejected: Fraud Detected"
			return false
		}
	}
	
	fmt.Printf("✅ 欺诈检测通过\n")
	return h.HandleNext(order)
}

// 3. 支付处理器
type PaymentHandler struct {
	BaseHandler
}

func (h *PaymentHandler) Handle(order *Order) bool {
	fmt.Printf("[支付处理] 处理订单 %s 的支付...\n", order.ID)
	
	// 模拟支付处理 - 3%概率支付失败
	if rand.Intn(33) == 0 {
		fmt.Printf("❌ 支付失败，订单 %s 被拒绝\n", order.ID)
		order.Status = "Rejected: Payment Failed"
		return false
	}
	
	fmt.Printf("✅ 支付处理成功\n")
	order.Status = "Paid"
	return h.HandleNext(order)
}

// 4. 物流处理器
type ShippingHandler struct {
	BaseHandler
}

func (h *ShippingHandler) Handle(order *Order) bool {
	fmt.Printf("[物流安排] 为订单 %s 安排配送...\n", order.ID)
	
	// 特殊地区检查
	if order.Address == "偏远地区" {
		fmt.Printf("⚠️ 订单 %s 为偏远地区，额外处理\n", order.ID)
	}
	
	// 生成运单号
	trackingNumber := fmt.Sprintf("TRACK-%d", time.Now().UnixNano())
	fmt.Printf("✅ 物流安排完成，运单号: %s\n", trackingNumber)
	order.Status = "Shipped"
	return h.HandleNext(order)
}

// 5. 通知处理器
type NotificationHandler struct {
	BaseHandler
}

func (h *NotificationHandler) Handle(order *Order) bool {
	fmt.Printf("[通知发送] 发送订单 %s 的通知...\n", order.ID)
	
	// 发送邮件通知
	fmt.Printf("✉️ 发送邮件到 %s: 订单 %s 已发货\n", order.Email, order.ID)
	
	// 发送短信通知
	fmt.Printf("📱 发送短信到 %s: 订单 %s 已发货\n", order.Phone, order.ID)
	
	order.Status = "Completed"
	fmt.Printf("🎉 订单 %s 处理完成\n", order.ID)
	return true
}
